package donkeykong;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;
import javax.swing.JPanel;

public class Espectro  extends JPanel implements Runnable {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	/** Numero de colores de escalera que el espectro debe reconocer para poder subirla **/
	private int COLORES_ESCALERA = 7;
	/** Velocidad de subieda/bajada de una escalera **/
	private int INCREMENTO_ESCALERAS = 0;
	/** VELOCIDAD DE MOVIMIENTO DEL ESPECTRO **/
	private int VELOCIDAD = 0;
	/** Indica si el espectro es una llama (true) o un zigurat (false) **/
	private boolean EsLlama;
	/** Imagenes de los espectros **/
	private Image llama_1_izq,llama_1_dch,llama_2_izq,llama_2_dch,
			llama_peligro_1_izq,llama_peligro_1_dch,llama_peligro_2_izq,llama_peligro_2_dch,
			zigurat_peligro_izq,zigurat_peligro_dch,imagen_espectro,imagen_destr_1,imagen_destr_2,
			imagen_destr_3,imagen_destr_4,zigurat_izq1,zigurat_izq2,zigurat_dch1,zigurat_dch2;
	
	private int sprite;
	/** Indica si el espectro esta mirando hacia la derecha (true) o a la izquierda(false) **/
	private boolean MiraEspectroDerecha;
	
	/** Posicion X del espectro **/
	private int posicion_y_espectro;
	/** Posicion Y del espectro **/
	private int posicion_x_espectro;
	/** Variable que indica si los espectros deben estar en modo peligro ( Mario tiene un mazo) o no **/
	private boolean peligroMazo;
	
	private Mario mario;
	
	private BufferedImage imagenFondo;
	/** Variable que indica la pantalla en la que esta el espectro **/
	private int pantallaActual;

	/** Variable que indica si la partida ha acabado por muerte / por ganada o no**/
	private boolean acabar;
	
	public boolean ponerPuntuacion;

	private Puntuacion_imagen puntuacion;
	Thread p;

	private Puntuacion_total score;
	
	private boolean espectro_muerto=false;

	private boolean destruccion;

	private Clip clickClip;

	private AudioInputStream musicaSonido;

	private boolean pasarela;

	private boolean[][] Plataformas;
	
	public Espectro(int posicion_x, int posicion_y, boolean EsUnaLlama, Mario m, BufferedImage imagen, int Velocidad, int VelocidadEsc, int pantalla, Puntuacion_total pt){
		EsLlama = EsUnaLlama;
		if (EsLlama)
			cargarLlama();
		else
			cargarZigurat();
		

		score = pt;
		try {
			imagen_destr_1 = ImageIO.read(new File("./images/destruccion/destruccion_1.png"));
			imagen_destr_2 = ImageIO.read(new File("./images/destruccion/destruccion_2.png"));
			imagen_destr_3 = ImageIO.read(new File("./images/destruccion/destruccion_3.png"));
			imagen_destr_4 = ImageIO.read(new File("./images/destruccion/destruccion_4.png"));
		} catch (IOException e) {
			e.printStackTrace();
		}


		setPosicionX(posicion_x);
		setPosicionY(posicion_y);
		mario = m;
		imagenFondo = imagen;
		
		puntuacion = new Puntuacion_imagen(mario,2);
		p = new Thread(puntuacion);
		
		VELOCIDAD = Velocidad;
		INCREMENTO_ESCALERAS = VelocidadEsc;
		pantallaActual = pantalla;
	}
	
	
	/** Setter de la posicion Y
	 * 
	 * @param posy : nuevo valor de la posicion Y del espectro
	 */
	private void setPosicionY(int posy) {
		posicion_y_espectro = posy;
	}


	/** Setter de la posicion X
	 * 
	 * @param posy : nuevo valor de la posicion X del espectro
	 */
	private void setPosicionX(int posx) {
		posicion_x_espectro = posx;
	}


	/** Getter de la posicion X
	 * 
	 * @return valor de la posicion X del espectro
	 */
	private int getPosicionX() {
		return posicion_x_espectro;
	}


	/** Getter de la posicion Y
	 * 
	 * @return valor de la posicion Y del espectro
	 */
	private int getPosicionY() {
		return posicion_y_espectro;
	}


	private void cargarZigurat() {
		try{
			zigurat_izq1 = ImageIO.read(new File("./images/espectros/z1_izq.png"));
			zigurat_izq2 = ImageIO.read(new File("./images/espectros/z2_izq.png"));
			zigurat_dch1 = ImageIO.read(new File("./images/espectros/z1_dch.png"));
			zigurat_dch2 = ImageIO.read(new File("./images/espectros/z2_dch.png"));
			
			zigurat_peligro_izq = ImageIO.read(new File("./images/espectros_azul/zigurat_azul_izq.png"));
			zigurat_peligro_dch = ImageIO.read(new File("./images/espectros_azul/zigurat_azul_dch.png"));
			
			imagen_espectro = zigurat_izq1;
		}catch (Exception e){
			e.printStackTrace();
		}
	}



	private void cargarLlama() {
		try{
			llama_1_dch =  ImageIO.read(new File("./images/espectros/llama_1_dch.png"));
			llama_1_izq =  ImageIO.read(new File("./images/espectros/llama_1_izq.png"));
			llama_2_dch =  ImageIO.read(new File("./images/espectros/llama_2_dch.png"));
			llama_2_izq =  ImageIO.read(new File("./images/espectros/llama_2_izq.png"));
			
			llama_peligro_1_dch = ImageIO.read(new File("./images/espectros_azul/llama_azul_1_dch.png"));
			llama_peligro_1_izq = ImageIO.read(new File("./images/espectros_azul/llama_azul_1_izq.png"));
			llama_peligro_2_dch = ImageIO.read(new File("./images/espectros_azul/llama_azul_2_dch.png"));
			llama_peligro_2_izq = ImageIO.read(new File("./images/espectros_azul/llama_azul_2_izq.png"));
			
			imagen_espectro = llama_1_dch;
		}catch (Exception e){
			e.printStackTrace();
		}		
	}

	
	
	/** Funcion para indicar que el espectro muere, con el mazo **/
	public boolean isAcabado() {
		return isEspectro_muerto();
	}

	
	/** Funcion paintComponent que es propia de los JPanels, que sirve para dibujar en el mismo la imagen que se quiera, entre otras opciones **/
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2d = (Graphics2D) g;
		
		AffineTransform at = new AffineTransform();
		
		
		at.translate(getPosicionX(), getPosicionY()- imagen_espectro.getHeight(null)); 

		/** Si el espectro es destruido, poner animacion de destruccion **/
		if (isDestruido()){
			if (!ponerPuntuacion){
				animacionDestruccion(imagen_espectro,at,g2d);
			}else{
				g2d.drawImage(imagen_espectro,at,null);
			}
		}else{
		
			if (!acabar){
				/** Si estan en peligro, pintar imagenes de peligro (azules) **/
				if (hayPeligro()){
					/** Comprobar si es llama o zigurat **/
					if (EsLlama){
						imagen_espectro = ((sprite<2)? (MirandoDcha()?llama_peligro_1_dch:llama_peligro_1_izq): 
							(MirandoDcha()?llama_peligro_2_dch:llama_peligro_2_izq));
						sprite = (sprite+1)%4;
					}else{
						imagen_espectro = ((MirandoDcha())? zigurat_peligro_dch: zigurat_peligro_izq);
					}
					
				/** Si no hay peligro, dibujar imagenes normales (rojas) **/	
				}else{
					/** Comprobar si es llama o zigurat **/
					if (EsLlama){
						imagen_espectro = ((sprite<2)? (MirandoDcha()?llama_1_dch:llama_1_izq): (MirandoDcha()?llama_2_dch:llama_2_izq));
						sprite = (sprite+1)%4;
					}else{
						imagen_espectro = ((sprite<2)? (MirandoDcha()?zigurat_dch1:zigurat_izq1): (MirandoDcha()?zigurat_dch2:zigurat_izq2));
						sprite = (sprite+1)%4;
					}
				}
				

				
			}
			g2d.drawImage(imagen_espectro,at,null);
			
			
			if (ponerPuntuacion){
				if (puntuacion!=null)
					puntuacion.paintComponent(g);
				
			}
		}
		
		
		
	}
	/** Animacion que se muestra cuando se destruye el espectro **/
	private void animacionDestruccion(Image imagen,	AffineTransform at, Graphics2D g2d) {
		Image image;
		image = ((sprite<2)? imagen_destr_1 : ((sprite<4)? imagen_destr_2 : ((sprite<6)? imagen_destr_3 :imagen_destr_4))); 	
		sprite=(sprite+1);
		/**Borrar espectro**/
		if (sprite==8){
			if (!isEspectro_muerto()){
				score.añadirPuntuacion(300);
				escucharSonido("item_points",0);
				try {
					imagen_espectro = ImageIO.read(new File("./images/300_puntos.png"));
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				ponerPuntuacion=true;
				puntuacion=null;

			}
			
		}
		g2d.drawImage(image,at,null);
		
	}


	/** Comprueba si el espectro esta mirando hacia la derecha o la izquierda
	 * 
	 * @return cierto si esta mirando hacia la derecha, falso si mira a la izquierda
	 */
	private boolean MirandoDcha() {
		return MiraEspectroDerecha;
	}

	/** Funcion para indicar que Mario ha muerto/se ha acabado la pantalla **/
	public void Acabar(){
		acabar = true;
	}
	


	@Override
	public void run() {
		try{
			while (true){
				
				if (mario.isInvencible() & ponerPuntuacion){
					Thread.sleep(1000);
					setEspectro_muerto(true);
				}
				
				/** Si el espectro ha muerto, matar el Thread **/
				if (isEspectro_muerto()){
					break;
			
				}else if (isDestruido()){
					
				}else if (!acabar){
					Thread.sleep(102);
					/** Comprobar el suelo, para hacer que el barril salga directamente del suelo.**/
					comprobarSuelo(getPosicionX()+imagen_espectro.getWidth(null)/2);
					/** Comprobar choque con Mario **/
					comprobarChoque();
					/** Añadir puntuacion si salta Mario por encima de el **/
					AñadirPuntuacionSalto();					

					
					Random rand2 = new Random();
					int realizarAccion = rand2.nextInt(5);
					if (realizarAccion==0){  //0 para subir
					
						int coloresAzules=0;
						// Comprobar el numero de pixeles del color de la escalera a lo largo de la imagen del espectro 
						for (int i=getPosicionX();i<=getPosicionX()+imagen_espectro.getWidth(null);i++){
							int c1 = imagenFondo.getRGB(i,getPosicionY()-1);
							Color color = new Color(c1);
							if (EsEscalera(color)){
								coloresAzules ++;
							}
						}

						/** Si el numero de colores de escalera se corresponde con el minimo para interactuar, se interactua con ella **/
						if (coloresAzules >= COLORES_ESCALERA){	

							/** Hasta que no termine de subir/bajar no parar **/
							int c1 = imagenFondo.getRGB(getPosicionX()+imagen_espectro.getWidth(null)/2,getPosicionY()-1);
							Color color = new Color(c1);
							while (!EsSuelo(color)){

								/** Comprobar pixel a pixel si estamos llegando a un color de suelo, que indicaria que termina el espectro
								 *  de subir/bajar **/
								Thread.sleep(102);
								for (int j=1;j<=INCREMENTO_ESCALERAS;j++){
									setPosicionY(getPosicionY()-1);
									c1 = imagenFondo.getRGB(getPosicionX()+imagen_espectro.getWidth(null)/2,getPosicionY());
									color = new Color(c1);
									if (EsSuelo(color)){
										setPosicionY(getPosicionY()-1);
										j=INCREMENTO_ESCALERAS;
									}
								
								}
							}
					
						}
					
					/** Si la diferencia entre Mario y el espectro es mayor de 20, el espectro debe bajar para buscarlo **/
					}else if (realizarAccion==2){  //2 para bajar

						int coloresAzules=0;
						// Comprobar el numero de pixeles del color de la escalera a lo largo de la imagen del espectro 
						for (int i=getPosicionX();i<=getPosicionX()+imagen_espectro.getWidth(null);i++){
							int c1 = imagenFondo.getRGB(i,getPosicionY()+1);
							Color color = new Color(c1);
							if (EsEscalera(color)){
								coloresAzules ++;
							}
	
						}
						/** Si el numero de colores de escalera se corresponde con el minimo para interactuar, se interactua con ella **/
						if (coloresAzules >= COLORES_ESCALERA){

							/** Hasta que no termine de subir/bajar no parar **/
							int c1 = imagenFondo.getRGB(getPosicionX()+imagen_espectro.getWidth(null)/2,getPosicionY()+2);
							Color color = new Color(c1);
							while (!EsSuelo(color)){

								/** Comprobar pixel a pixel si estamos llegando a un color de suelo, que indicaria que termina el espectro
								 *  de subir/bajar **/
								Thread.sleep(102);
								for (int j=1;j<=INCREMENTO_ESCALERAS;j++){
									setPosicionY(getPosicionY()+1);
									c1 = imagenFondo.getRGB(getPosicionX()+imagen_espectro.getWidth(null)/2,getPosicionY());
									color = new Color(c1);
									if (EsSuelo(color)){
										j=INCREMENTO_ESCALERAS;
									}
								
								}
							}
					
						}
						
					}
						/** Se decide si seguir a Mario o no segun la dificultad, cuanto mas alta, mas posibilidades de seguirlo **/
						Random rand = new Random();
						int seguirMario = rand.nextInt(6); // TODO cambiar la decision segun la dificultad, (3 LVL1, 2 LVL2,3, 1 LVL4+)
	
						if (seguirMario==1){
							if (ponerPuntuacion){
								if (puntuacion.Acabar()){
									score.añadirPuntuacion(100);
									puntuacion.setAcabar(false);
									p = new Thread(puntuacion);
									ponerPuntuacion = false;	
								}
							}
							for (int i=1;i<=VELOCIDAD;i++){
								if (pasarela){
									
								}else{
									if (!acabar){
										comprobarSuelo(getPosicionX()+imagen_espectro.getWidth(null)/2);
										int posMariox = mario.getPosicion_x();
										if (posMariox > getPosicionX()){	
											if (pantallaActual!=1){
												int c1 = imagenFondo.getRGB(getPosicionX()+imagen_espectro.getWidth(null),getPosicionY());
												Color color = new Color(c1);
												if (!EsAire(color)){
													if (!mario.detectarColision_dch(((MiraEspectroDerecha)? getPosicionX()+imagen_espectro.getWidth(null):getPosicionX() ))){
														setPosicionX(getPosicionX() + 1);
													}
												}
											}else{
												if (!mario.detectarColision_dch(((MiraEspectroDerecha)? getPosicionX()+imagen_espectro.getWidth(null):getPosicionX() ))){
													setPosicionX(getPosicionX() + 1);
												}
											}
											MiraEspectroDerecha=true;
										}else{
											if (pantallaActual!=1){
												int c1 = imagenFondo.getRGB(getPosicionX(),getPosicionY());
												Color color = new Color(c1);
												if (!EsAire(color)){
													if (!mario.detectarColision_dch(((MiraEspectroDerecha)? getPosicionX()+imagen_espectro.getWidth(null):getPosicionX() ))){
														setPosicionX(getPosicionX() - 1);
													}
												}
											}else{
												if (!mario.detectarColision_dch(((MiraEspectroDerecha)? getPosicionX()+imagen_espectro.getWidth(null):getPosicionX() ))){
													setPosicionX(getPosicionX() - 1);
												}
											}
											MiraEspectroDerecha=false;
										}
										/** Comprobar choque con Mario **/
										comprobarChoque();
										/** Añadir puntuacion si salta Mario por encima de el **/
										AñadirPuntuacionSalto();
									}else{
										break;
									}
								}
							}
							
						}else{
							int aleatorio = rand.nextInt(10);
								for (int i=1;i<=VELOCIDAD;i++){
									if (pasarela){
										
									}else{
										if (!acabar){
											comprobarSuelo(getPosicionX()+imagen_espectro.getWidth(null)/2);
											if (pantallaActual!=1){
												int c1 = imagenFondo.getRGB(((MiraEspectroDerecha)? getPosicionX()+imagen_espectro.getWidth(null):getPosicionX() ),getPosicionY());
												Color color = new Color(c1);
												if (!EsAire(color)){
													if (!mario.detectarColision_dch(((MiraEspectroDerecha)? getPosicionX()+imagen_espectro.getWidth(null):getPosicionX() ))){
														setPosicionX(getPosicionX() + ((MiraEspectroDerecha)? 1:-1 ));
													}
												}else{
													if (!mario.detectarColision_dch(((MiraEspectroDerecha)? getPosicionX()+imagen_espectro.getWidth(null):getPosicionX() ))){
														setPosicionX(getPosicionX() + ((MiraEspectroDerecha)? -1: 1 ));
														MiraEspectroDerecha=!MiraEspectroDerecha;
													}
												}
											}else{
												if (!mario.detectarColision_dch(((MiraEspectroDerecha)? getPosicionX()+imagen_espectro.getWidth(null):getPosicionX() ))){
													setPosicionX(getPosicionX() + ((aleatorio<5)? 1: -1));
													MiraEspectroDerecha = ((aleatorio<5) ? true: false);
												}
											}
											
											/** Comprobar choque con Mario **/
											comprobarChoque();
											/** Añadir puntuacion si salta Mario por encima de el **/
											AñadirPuntuacionSalto();
										}else{
											break;
										}
									}
								}
							
						}
					
				}else{
					break;
				}
				
				
				
				
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}

	/** Funcion que comprueba si el centro del espectro coincide con el centro de Mario, y que éste este en una posicion Y inferior ( este por encima ) **/
	private void AñadirPuntuacionSalto() {
		/** Punto central del espectro **/
		int posicion_centro_x = getPosicionX()+ imagen_espectro.getWidth(null)/2 ;
		int posicion_centro_y = getPosicionY()- imagen_espectro.getHeight(null)/2 ;
		
		/** Punto central de Mario **/
		int mario_centro_x = mario.getPosicion_x()+mario.getImage().getWidth(null)/2;
		int mario_centro_y = mario.getPosicion_y()-mario.getImage().getHeight(null)/2;
		
		/** Solo sumar puntuacion si Mario esta saltando, el espectro pasa por el centro X de Mario, y la diferencia de altura es la de un salto **/
		if (mario.isSaltando() & posicion_centro_x==mario_centro_x & Math.abs(posicion_centro_y-mario_centro_y)<45){
			if (!ponerPuntuacion){
				if (!p.isAlive()){
					try{
					p.start();
					ponerPuntuacion=true;
	
					}catch(IllegalThreadStateException e){
					}
				}
			}
		}

	}


	/**
	 * Funcion que comprueba si los espectros estan en peligro (true) o no (false)
	 * @return cierto si estan en peligro, falso en caso contrario
	 */
	private boolean hayPeligro() {
		return peligroMazo;
	}

	/**
	 * Funcion que modifica la variable de peligro sobre los espectros, 
	 * @param peligro booleano que indica si los espectros estan en peligro (true) o no (false)
	 */
	private void modificar_peligro(boolean peligro) {
		peligroMazo = peligro;
	}

	/** Funcion que es llamada externamente para avisar de peligro al espectro **/
	public void Alerta(){
		modificar_peligro(true);
	}
	
	/** Funcion que es llamada externamente para avisar de que ha cesado el peligro al espectro **/
	public void Descanso(){
		modificar_peligro(false);
	}
	
	
	/** Funcion de comprobar suelo, sirve para poder moverse por la pantalla, poder caer, subir/bajar escaleras,etc **/
	public void comprobarSuelo(int centroEspectro){
		try{
			int c1 = imagenFondo.getRGB(centroEspectro,getPosicionY());
			Color color = new Color(c1);
			
			if (pantallaActual==3){
				/** Identificamos si mario esta pasando por una de las dos plataformas (SOLO EN EL ULTIMO NIVEL)**/
				if((centroEspectro>172&&centroEspectro<253)||((centroEspectro>530&&centroEspectro<594))){ //Posicion de las plataformas
					pasarela = true;
					int nivel=0;
					if(getPosicionY()==480){	
						nivel=0;
					}
					else if(getPosicionY()==376){				
						nivel=1;
					}
					else if (getPosicionY()==272){
						nivel=2;
					}
					else if(getPosicionY()==167){
						nivel=3;
					}
					if (centroEspectro>172&&centroEspectro<253){
						if (MirandoDcha()){
							if (Plataformas[nivel][0]==false){
								for (int i=1;i<=30;i++){
									setPosicionX(getPosicionX()+1);
									MiraEspectroDerecha=true;
									Thread.sleep(30);
								}	
						    }
						}else{
							if (Plataformas[nivel][0]==false){
								for (int i=1;i<=30;i++){
									setPosicionX(getPosicionX()-1);
									MiraEspectroDerecha=false;
									Thread.sleep(30);
								}	
							}
						}
						
					}else{
						if (MirandoDcha()){
							if (Plataformas[nivel][1]==false){
								for (int i=1;i<=30;i++){
									setPosicionX(getPosicionX()+1);
									MiraEspectroDerecha=true;
									Thread.sleep(30);
								}
							}
						}else{
							if (Plataformas[nivel][1]==false){
								for (int i=1;i<=30;i++){
									setPosicionX(getPosicionX()-1);
									MiraEspectroDerecha=false;
									Thread.sleep(30);
								}	
							}
						}
						
					}
					
					pasarela = false;	
				}
			}
			/** Comprobar el suelo si es negro, (color del aire) , es bajar posicion 'y' hasta encontrar color de suelo **/
			if ((EsAire(color))){
				if (pantallaActual==1){
					c1 = imagenFondo.getRGB(centroEspectro,getPosicionY());
					color = new Color(c1);
					/** Mientras el color no sea el del suelo, bajar **/
					while (!(EsSuelo(color))){
						if(!acabar){
							 setPosicionY(getPosicionY()+1);
							 Thread.sleep(10);
							 c1 = imagenFondo.getRGB(centroEspectro,getPosicionY());
							 color = new Color(c1);
							 comprobarChoque();
						}else{
							break;
						}
					}
				}else{
					 setPosicionY(getPosicionY()+1);
				}
			}else if (!EsSuelo(color)){
				c1 = imagenFondo.getRGB(centroEspectro,getPosicionY());
				color = new Color(c1);
				boolean seguirSubiendo=true;
				 if ((EsAire(color))|((EsEscalera(color)))){
					 seguirSubiendo=false;
				 }
				
				/** Mientras no se llegue a color de aire o escalera, subir a Mario **/
				while (seguirSubiendo){
			 	 setPosicionY(getPosicionY()-1);	
				 c1 = imagenFondo.getRGB(centroEspectro,getPosicionY());
				 color = new Color(c1);
				 if ((EsAire(color))|((EsEscalera(color)))){
					 seguirSubiendo=false;
				 }
				}
		
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	/** Funcion que comprueba si se realiza un choque del espectro con Mario **/
	private void comprobarChoque() {
		/** Punto central del espectro **/
		int posicion_centro_x = getPosicionX()+ imagen_espectro.getWidth(null)/2 ;
		int posicion_centro_y = getPosicionY()- imagen_espectro.getHeight(null)/2 ;
		
		/** Esquinas de la imagen de Mario **/
		int mario_x_final = mario.getPosicion_x()+mario.getImage().getWidth(null);
		int mario_x_inicial = mario.getPosicion_x();
		int mario_y_final = mario.getPosicion_y();
		int mario_y_inicial = mario.getPosicion_y()-mario.getImage().getHeight(null);
		
		
		/** Si el centro del espectro  choca con la imagen de Mario, éste muere **/
		if (posicion_centro_x <= mario_x_final & posicion_centro_x >= mario_x_inicial){
			if (posicion_centro_y <= mario_y_final & posicion_centro_y >= mario_y_inicial){
				if (!mario.isInvencible())
					mario.Muriendo();
				else
					if ((mario.MirandoDcha() & MiraEspectroDerecha & mario.getPosicion_x()==getPosicionX()+imagen_espectro.getWidth(null))|(!mario.MirandoDcha() & !MiraEspectroDerecha& mario.getPosicion_x()+mario.getImage().getWidth(null)==getPosicionX())){
						mario.Muriendo();
					}else{
					Destruccion();
					}
			}
		}
	}

	/** Espectro muere por el mazo **/
	private void Destruccion() {
		escucharSonido("destruido",0);
		/** Animacion destruccion **/
		setDestruido(true);
		
	}


	/** Funcion que dado un color, indica si es el color del suelo **/
	public boolean EsSuelo(Color color){
	if (pantallaActual == 1){
		return (color.getRed()>250 & color.getGreen()<50 & color.getBlue()>100);
	}else if (pantallaActual == 2){
		return (color.getRed()>230 & color.getGreen()<70 & color.getBlue()>138);
	}else return (color.getRed()<30 & color.getGreen()>50 & color.getBlue()>250);
	}

	/** Funcion que dado un color, indica si es el color del aire **/
	public boolean EsAire(Color color){
		return (color.getRed()==0 & color.getGreen()==0 & color.getBlue()==0);
	}

	/** Funcion que dado un color, indica si es el color de una escalera **/
	public boolean EsEscalera(Color color){
	if (pantallaActual == 1){
		return (color.getRed()<6 & color.getGreen()>200 & color.getBlue()>200);
	}else if (pantallaActual == 2){
		return (color.getRed()<3 & color.getGreen()>240 & color.getBlue()>225);
	}else return (color.getRed()<=252 & color.getGreen()>=160 & color.getBlue()>=68);
	}


	public boolean isDestruido() {
		return destruccion;
	}


	private void setDestruido(boolean destruccion) {
		this.destruccion = destruccion;
	}


	private boolean isEspectro_muerto() {
		return espectro_muerto;
	}


	private void setEspectro_muerto(boolean espectro_muerto) {
		this.espectro_muerto = espectro_muerto;
	}

	/** Funcion que permite reproducir un sonido
	 * 
	 * @param sonido : Nombre (sin extension) del sonido a reproducir
	 * @param duracion : Duracion de la musica por si qse quiere repetir indefinidamente o solo unas veces
	 */
	public void escucharSonido(String sonido, int duracion){
		try {
			clickClip = AudioSystem.getClip();
			musicaSonido = AudioSystem.getAudioInputStream(new File("./sounds/"+sonido+".wav"));
			clickClip.open(musicaSonido);
			clickClip.loop(duracion);
			clickClip.start();
		} catch (LineUnavailableException e) {
			e.printStackTrace();
		} catch (UnsupportedAudioFileException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	
	/** Funcion que se utiliza para parar el sonido, si esta activado **/
	public void pararSonido(){
		if(clickClip != null){
			clickClip.stop();
			clickClip.close();
		}
	}
	
	
	public void setPlataformas(boolean[][] plat){
	 Plataformas = plat;
	}
	
}
